Inputs and outputs are always the exactly the same structure...
... regardless of map format.
Requesting tile data from Map2 will output the data...
... in exactly the same form as requesting from Map3.



#						data.get.tileSize()

#						data.get.width()

#						data.get.height()

#						data.get.tileChipIndex( location )
							location:	{ layer, x, y }

#						data.get.chipsetQuantity()

#						data.get.maxChipsetQuantity()

{width,height}		data.get.maxChipsetSize();		(in tiles)

tileData			data.get.tile( location )
							location:	{ layer, x, y }
							tileData:		{ chipset, x, y }		(Always returns this, even when accessing Map2)

#						data.get.layerQuantity()

""						data.get.chipsetFile( chipsetIndex )
							"chipset's image filePath"

[chipsetData]	data.get.allChipsets()
								[array of filePaths]		(always returns an array, even when editing Map2)

mapData		data.get.data()

#						data.get.collisionTile( location )
							location:	{ x, y }
							#  Returns the collisionValue stored in that location of the map



-						data.set.tileSize( newTileSize )

-						data.set.width( newWidth )

-						data.set.height( newHeight )

-						data.set.chipsetFile( chipsetIndex, filePath )

-						data.set.allChipsets( [chipsetData] )
							Always requires an array of filePaths, even when editing Map2

-						data.set.tile( location, tileData )
							location:	{ layer, x, y }
							tileData:		{ chipset, x, y }		(Always requires this data, even when editing Map2)

-						data.set.tileChipIndex( location, newChipIndex )
							location:	{ layer, x, y }

-						data.set.data( mapData )

-						data.set.collisionTile( location, collisionID )
							location:	{ x, y }



-						data.add.chipset( chipFilePath )

-						data.add.layer( layer, tile )
							tile:  {chipset, x, y}



-						data.remove.chipset( chipIndex )

-						data.remove.layer( layerIndex )



-						data.modify.shiftTilesHorz( xOffset )
-						data.modify.shiftTilesVert( yOffset )

-						data.modify.wrapTilesHorz( xOffset )
-						data.modify.wrapTilesVert( yOffset )



tileData			data.create.blankTile()

tileData			data.create.tileFromChipset( xChip, yChip, chipsetIndex )

un-compressedMapData		data.create.map( width, height, tileSize, format )
														width, height, tileSize, format  are all optional

compressedMapData				data.create.compressedMap( uncompressedMapData )

un-compressedMapData		data.create.uncompressedMap( compressedMapData )

collisionValue							data.create.blankCollisionValue()



tileData			data.copy.tile( tileData )



Check data from .change() reactions...
... and wrap map data into temporary collections
	myObj.reactTo( data.any ).change = function(){}
	myObj.reactTo( data.chipsets ).change = function(){}